Exact algorithms based on specific complexity measures for hard problems

At present, most of the important computational problems—be they decision, search, or optimization problems—are known to satisfy one of the following two criteria: 1. The problem can be solved in polynomial time with respect to the input size n, where the degree of the polynomial is small enough to guarantee that the problem can be tackled efficiently in practice. In particular, the decision version of the problem is in P. Typical time complexities are O(n log n) and O(nk), k ≤ 3. 2. The problem is NP-hard, and its decision version is NP-complete. We do not know whether the problem can be solved in polynomial time, but it is complex enough to express every other NP-complete problem via polynomial-time transformations. A typical time complexity for this case is O(cn) with c > 1.1. Under the widely accepted assumption that P6=NP, exact algorithms for problems of the second variety inevitably take superpolynomial time (not necessarily for every input, but in the worst case). In terms of worst-case behavior, it is easy to see that the respective algorithms can be infeasible even for instances of moderate size. The thesis at hand addresses this intricacy by combining two concepts, one of which is a well-known paradigm and the other one of which is an analytical tool that has only been used less explicitly in earlier scholarship. Firstly, we consider the parameterized complexity of hard graph problems. In particular, we design and analyze parameterized algorithms, i.e., algorithms whose running times are typically exponential in some parameter of the input (such as the desired size of the solution), but only polynomial in the size of the input. The most important of the resulting runtime bounds are: O((2 + ε)k · poly(n)) to find an optimum Steiner tree for k terminals O(2.7606k · poly(n)) to check for a k-node connected vertex cover O(3.2361k · poly(n)) to check for a k-node tree cover of weight ≤W O(1.3803k · poly(n)) to count all vertex covers of size up to k O(4k · poly(n)) to check for a k-node path O((16 + ε)k · poly(n)) to check for k edge-disjoint triangles All of the above results constitute the best parameterized runtime bounds for the respective problems known today. Secondly, we employ problem-specific complexity measures: we identify quantities whose smallness can be exploited in order to solve the problem more efficiently, then prove that they are small in any case, or that they can be made small using bounded additional effort. Such complexity measures